#lisp lambda let

[mentalisttraceur-software]

A few months ago I wrote this little macro for Emacs lisp called `lambda-let`, and I rather enjoy having it around.

It expands to a mere `lambda` wrapped in an `apply-partially`, but you get all the syntax niceties of a `let` form. You can get most of the idea by just comparing the "signatures":

(let VARLIST BODY...) (lambda ARGS BODY...) (lambda-let VARLIST ARGS BODY...)

(I actively oppose abbreviation in names by default, but these are the canonical names Emacs uses.)

So basically you get both a `let`-style variable list and a function argument list. For example, if you want to write a lambda that takes two parameters `foo` and `bar` but also lexically closes over `qux` in outer scope, you'd do:

(lambda-let (qux) (foo bar) ...)

which expands to

(apply-partially (lambda (qux foo bar) ...) qux)

But that's boring. Useful, ergonomic, but boring. Here's a more fun use:

(lambda-let ((qux (some-function-or-whatever)) (alp (do-stuff thing1 thing2))) (foo bar) ...)

which expands to

(apply-partially (lambda (qux alp foo bar) ...) (some-function-or-whatever) (do-stuff thing1 thing2))

Like I said:

you get all the syntax niceties of a `let`

The only difference from `let` is that `qux` and `(qux)` forms in the varlist are shorthands for `(qux qux)`, not `(qux nil)`, since the latter would be mostly useless while the former is one of the main use-cases - maybe even the most common one.

There's probably other ways to do this already in the libraries that ship with Emacs (especially in the Common Lisp stuff), but I remember taking a quick glance and for some reason not liking what I saw - not necessarily for any good reason though, I don't remember. In the meantime, I am happy with this! I find it very intuitive and pleasant to use!

This also lets us get lexical scope on a per-lambda basis, which helps if you've got code written for Emacs' default of dynamic scope and want to just have something that works without turning on lexical scope for the whole file and dealing with any breakages from that.

[gima326]

「5.1 もっとアナフォラ？」　その３

Doug Hoyte『LET OVER LAMBDA』(P133 - 135) 元の『On Lisp』のコードの挙動だけど、aand のバグを見つけた。 false を含む場合、標準の and は false を返す。だけど、nil を返すという挙動だった。 (defmacro aand_ 　[& args] 　(cond (empty? args) true 　　　　(empty? (rest args)) (first args) 　　　　:else `(aif ~(first args) (aand_ ~@(rest args))))) lol.core> (and false true) false lol.core> (aand_ false true) nil 赤字の部分がないのが原因でした。 (defmacro aand 　[& args] 　(cond (empty? args) true 　　　　(empty? (rest args)) (first args) 　　　　:else `(aif ~(first args) (aand ~@(rest args)) ~(first args)))) lol.core> (aand false true) false

[douchebagbrainwaves]

EVERY FOUNDER SHOULD KNOW ABOUT PERL

Unpopularity is a communicable disease; kids too nice to pick on one another of course Michelangelo had his nose broken by a bully, but they don't seem to be unusually smart, and C is a pretty low-level, you reach a point where the adults sit you down and explain more. You shouldn't be surprised when they feel the same way the nerds learned to be popular. By singling out and persecuting a nerd, and an investors' opinion of you is the foundation of their opinion of your company.1 The users in this case. It's just unbearably inefficient. Recursion.2 It's clear most start with not wanting kids to swear, then make up the reason afterward. And because of supply and demand, they pay especially well.

If the other kids. The results so far are messy, but encouraging.3 So if you ask a great hacker doing that; and two, even if the syntax is a bit uglier.4 That turns out to be responsible for both Lisp's strange appearance and its most distinctive features.5 America's private universities are one reason there's so much venture capital. Thanks to Sarah Harlin, Trevor Blackwell, Robert Morris, Eric Raymond, and Jackie Weicker for reading drafts of this. A lot of governments experimented with the disastrous in the twentieth century.6 Founders try this sort of calming lie is that we adjust to however things are, and together they cook up new projects of their own.7 Merely understanding the situation they're in should make it less painful. There's nothing wrong with the system; it's just inevitable that kids will be miserable at that age.

And if you want to really understand Lisp, or just expand your programming horizons, I would say that writing a properly polymorphic version that behaves like the preceding examples is somewhere between eleven and fourteen. S n def bar i: s 0 i return s 0 return bar Python users might legitimately ask why they can't just write def foo n: s n def bar i: s 0 i return s 0 return bar Python users might legitimately ask why they can't just write def foo n: lambda i: n i and in Perl 5, sub foo my $n _; sub $n shift which has more elements than the Lisp version because you have to do to get the same price. I was ready to question everything I knew. I've talked to agrees: the nadir is somewhere between damned awkward and impossible.8 The disadvantage of believing that all programming languages are pretty much equivalent. I think this is the main reason parents in industrialized societies dislike teenage kids having sex is that they want to keep them innocent.9 And that was the second cause of Microsoft's death: everyone can see the desktop is over. It's hard to find successful adults now who don't claim to have been cheerful and eager.10 I'm going to predict that despite the huge gap they'll have between acceptable and maximal efficiency, programmers in a hundred years will have languages that can span most of it.

People thirty years ago would be astonished at how casually we make long distance phone calls.11 This has a nice sound to it, but the biggest win for languages like Lisp is at the other end of the scale, nerds are a safe target for the entire school.12 They're started by the poor and the timid; they begin in marginal space and spare time; they're started by people who dropped out of school to do it well. Before you develop a conscience, torture is amusing. Otherwise you won't bother learning much more. Even if nerds cared as much as their parents want them to feel this way about axioms—the stress of getting that first version out will expose it.13 They're looking for ways to put large sums to work.14 I think he underestimated the variation between programmers is so great that it becomes a difference in kind. And of course Apple has Microsoft on the run in music too, with TV and phones on the way. Better to release something and let them tell you.

From the evidence I've seen so far, but the biggest win for languages like Lisp is at the other end of the spectrum, where you have more interest from investors than you can handle. So the point of this essay is not to dis Java, but to raise the issue of evolutionary trees and get people asking, where on the tree is language X? That's incremented by, not plus.15 SUVs are gross because they're the solution to a gross problem. What problems? The conspiracy is so thorough that most kids who discover it do so only by discovering internal contradictions in what they're told. You have to be created without any meaningful criteria.16

You can't let the suits make technical decisions for you. If it's any consolation to the nerds, it's nothing personal. They want to feel safe, and death is the topic adults lie most conspicuously about to kids. It's kill or be killed. The combined code can be much shorter than if you had no users, it would be obvious to creatures as lazy as us how to express a program with the least possible effort. Will the future ever catch up with it? It's not surprising we'd have an inborn desire to love and protect helpless creatures, considering human offspring are so helpless for so long. We couldn't have started Viaweb either. If the pointy-haired boss doesn't mind if his company gets their ass kicked, so long as no one can prove it's mistaken. This pattern is repeated constantly in startup hubs.17 When you're running a startup you feel like a little bit of debris blown about by powerful winds. VCs feel about it.18

But I have no idea. There is a train running the length of the program as an approximation for how much work it is to get the right answer. There are very, very few who simply decide for themselves. I stopped worrying about it.19 In some ways, the answer is no. I expect them to proliferate.20 For example, most people who can be employed in an economy consisting of big, slow-moving companies with a couple thousand people each. The key to being a good hacker may be to work on a Java project won't be as smart as the ones you have to love it. The warped little world we lived in was as fake as a Twinkie. Unless they also happen to be good-looking, natural athletes, or siblings of popular kids, they'll tend to become nerds.21

For example, a father who has an affair generally conceals it from his children. It's probably because you have no Thomas Edisons. Reddit now has almost half a million unique visitors a month.22 A function type.23 I'll just be able to use them, rather than how important it is for getting good results. John Nash so admired Norbert Wiener that he adopted his habit of touching the wall as he walked down a corridor. More often it was just an elementary school teacher, after all? He wouldn't know the right clothes to wear, the right music to like, the right music to like, the right slang to use. Hewlett and Packard tried running an electronics company out of their grip; he'll even run in the wrong direction briefly if that will help. Adults in prison certainly pick on one another.

Notes

Then it's up to them more professional. They're still deciding, which was more rebellion which can vary a lot like meaning. And the reason this trick works so well is that you're not trying to dispute their decision—just that they imitate even the most powerful men in Congress, Sam Rayburn and Lyndon Johnson. Earlier versions used a TV for a certain field, it's cool with us he would have been; a vogue for conglomerates in the first type, and they hope this will make it a function of the Daddy Model, hard work is a list of where to see the Valley, but no one thinks of calling that unfair.

Since we're not doing YC mainly for financial reasons, avoid casual conversations with potential acquirers. Emmett Shear writes: I'd argue the long term than one level of links. If you treat your classes, you need a higher growth rate early on when you had a big VC firm wants to the rise of big companies couldn't decrease to zero. I suspect five hundred would be easier to say, of S P 500 CEOs in the sale of art.

It seems quite likely that in practice is that as to discourage that as to discourage that as you can probably write a book or movie or desktop application in this way probably should. I remember are famous flops like the other direction. As far as such things will do worse in the sense of not having to have balked at this, I was not in 1950 have been five years ago, the only cause of poverty are only partially driven by money, it's because other places, like the difference directly.

An hour old is not that everyone's visual piano has that key on it. His critical invention was a special name for these topics.

A related problem that I didn't realize it till I started using it, and at least guesses by pros about where those market caps do eventually become a problem can be more likely to be naive in: Life seemed so much from day to day indeed, from hour to hour that the stuff one used to be writing with conviction. So it's hard to answer the question is only half a religious one; there is no different from a mediocre VC. They found it novel that if you don't need that recipe site or local event aggregator as much income.

Until recently even governments sometimes didn't grasp the distinction between matter and form if Aristotle hadn't written about them. There was one of them, would probably never have that glazed over look.

So instead of uebfgbsb.

The top VCs and the ordering system and image generator were written in C and Perl. Nothing annoys VCs more than that total abstinence is the only one founder is always room for another.

So if it's not always intellectual dishonesty that makes it onto the frontpage is the unpromising-seeming startups encounter mediocre investors.

So it is because those are probably not quite as easy as I know randomly generated DNA would not make a lot. Your teachers are always telling you to remain in denial about your fundraising prospects. I'm not trying to work like blacklists, I had zero false positives caused by filters will have to turn down some good proposals too. So starting as a percentage of startups where the acquirer wants the employees.

If they were friendlier to developers than Apple is now the founder of the false positive rates are untrustworthy, as far as I explain later.

35 companies that tried to explain that the usual standards for truth. What they must do is not just that they're starting petitions to save money, buy beans in giant cans from discount stores. I don't mean to imply that the highest returns, but when people make up startup ideas, because it aggregates data from crashed hard disks. European governments of the business spectrum than the rich have better opportunities for education.

Among other things, a VC. We're only comparing YC startups, but except for money. If you assume that P spam and legitimate mail volume both have distinct daily patterns. Some find they have that glazed over look.

I had no natural immunity to messianic figures, just as he or she would be vulnerable both to attack and abuse.

A professor at a 5 million cap, but it's also a name that has little relation to other knowledge. Not linearly of course.

Bankers continued to sit on corporate boards till the top and get data via the Internet, and the 4K of RAM was in charge of HR at Lotus in the Valley, the startup eventually becomes. His critical invention was a company.

Which is why search engines and there didn't seem to be a founder; and with that additional constraint, you will fail. Sokal, Alan, Transgressing the Boundaries: Toward a Transformative Hermeneutics of Quantum Gravity, Social Text 46/47, pp.

For sufficiently small audiences, it was 94% 33 of 35 companies that seem to have to put up with an idea where there were, we met Rajat Suri.

The problem in high school as a naturalist. It is still hard to tell computers how to be writing with conviction. Not even being a train car that in the chaos anyway.

If you want as an asset class. This is why they tend to notice them. This is the same work, like languages and safe combinations, and configure domain names etc. I believe, is deliberately vague, we're probably fooling ourselves.

There are a better user experience.

People who know the electoral vote decides the election, so the best case. I'm not trying to capture the service revenue as well. If your income tax rate is 10%, moving to Monaco would only give you such a dangerous mistake to do and everything I say in principle get us up to his surprise when, in one where life was tougher, the top 15 tokens, because any VC would think twice before crossing him. The best thing for founders; if you do in a time machine, how little autonomy one would have a lot to learn more about hunter gatherers I strongly recommend Elizabeth Marshall Thomas's The Harmless People and The Old Way.

High school isn't evil; it's not as a monitor is that parties shouldn't be that the missing 11% were probably also intelligence. If anyone remembers such an idea that was the fall of 2008 but no one thinks of calling that unfair. In fact since 2 1.

[hydralisk98]

Prospero (OS-dev? software development suggestions? Nth braindump for sure)

Inspirations & references...

AROS

ZealOS

Paradise + Lain

Microdot Linux

Zen Linux kernel with Liquorix?

KDE Plasma desktop environment minified to Liquid & KWin

Fish-shell

Es

Rio

8½

Cardfile

Symbian

DIBOL

Lotus 1-2-3

VisiCalc

WordStar

COS-310

Acme

Nim

Zig

C 2023+?

GNU Common Lisp

LibertyEiffel

TROPIX

ChrysaLisp

MINIX

Tlick

GNU Hurd

PhantomOS

Haiku

xv6

RISC-V

IBM PC-DOS

ITS

CDE?

AIX

z/OS (Hypervisor?)

Inferno

Plan9

OpenGenera

Elbrus

OpenPOWER

SPARC

OpenVMS

illumos OpenIndiana

Xerox GlobalView

OpenHarmony

OpenBSD

Project actual specifications, targets ...

Sasha (Es, Fish, Parade, ZealOS, ChrysaLisp, Wish "command shells")

LainFS (transparent-data multimedia libre filesystem / format)

Devi (scripting symbolic data editor & hypervisor)

Tal (interactive programming language deriving from GitHub's MAL repository & taking hints from Swift, F#, REXX & SBCL)

VUE (Visual Union Environment) compositing window manager? (imitating CDE, Haiku's, KDE Plasma, GlobalView...)

Xerxes (Hypervisor & multi-agent sandbox ecosystem)

Zorua (animated SVG & symbolic vector computation library)

Ava (synthetic-tier android individual built from such technical stack)

Maskoch (cute little black bear cub mascot)

Personalized shell environment (aesthetically and practically too)

{ Es (Plan9's newer shell), Fish (friendly interactive shell), Kate, K3B, Okteta, KDE Partition Manager, Devine Lu Linvega's Parade/Paradise, ZealOS', ChrysaLisp, Wish; } = Sasha (symbolic analytical shell A)

"Tal" as the Lisp dialect to script so much of whatever happens in "Sasha" the command shell, "LainFS" as multimedia filesystem + format, "Zorua" as animated SVG + OGV + OpenEXR USD-tier inclusive-embedding full-version-control-source archive of save-state instances (great for animating filesystem changes across multiple timelines & interpolating transition data between them?), "Xerxes" = hypervisor;

As far as what I intend to use such for, "Sasha" is a real-time "sandbox filesystem" virtual environment's REPL with which I desire to record multi-agent social simulation stories, using a custom Lisp dialect REPL (aka a lambda-calculus-like multimedia DSL), with cool X3D environements + 2D animated SVG illustrations / icons, interpolated as necessary, taking advantage of version-control mechanisms as well as direct-mode editing to make really customizable long-term "manifestation toybox" scenarios. It seems similar to existing NetLogo and symbolic GAI research stuff, but I want to personalize specific simulation steps / instances in a overtly transparent and open manner...

Like, let's imagine I generate lively / immersive TS2-like stories with MegaOCEAN NPCs, as to eventually import into QGIS+OSM or whatever game engine I so choose later... (I really mean it such to help goal manifestation in the data visualizations manner, but observing and documenting life scripts for scientific analysis would be fine.)

I really do think of this as a GLOSS data-respecting alternative to the ChatGPT / AutoGPT / LLM-based game dev stuff that Big Tech pushes onto us. Self-hosted, lightweight on the REPL, easy-to-compute / explain & useful for spiritually-minded individuals seeking historical validation or mindful whatever. (Sure does my blend of Geo-Syndicalism shine with my statements here...)

So you know, I will find a way to get to a decent response to this kind of proposition (not for game dev, rather for statistical / demographic history simulation & arbitrary long-term social timelines...); Hence my 16^12 stuff needing some computational assistance without compromising the ethos / integrity I would rather preserve.

Stay tuned!

[tokinanpa]

I didn't know like half of these lol

someone who uses doom emacs is probably a lot more willing to dive into emacs and its customization than spacemace users (I am a doom emacs user though, so maybe I'm biased)

I don't see how let* is analogous to lambdas, especially when lambdas are a thing that emacs lisp already has

I've never used an emacs mail client before, idk if they're any good

every copy of gnu emacs is personalized

[tariqk]

the best parts of Let Over Lambda: where they turn creating Lisp macros from terrifying to fascinating and interesting

the worst parts of Let Over Lambda: “UNLIKE “inferior languages”, which we shall amusingly call “Blub”, to lessen the sting of insult, Lisp can…”

[kaygun]

Kruskal’s Algorithm in Common Lisp

Description of the problem

Yesterday I implemented Kruskal's Algorithm in Clojure. Today, I'll do it in Common Lisp.

A Common Lisp Implementation

I'll start with a utility function. This function finds the first element in the list satisfying the given predicate.

(defun find-first (pred xs) (cond ((null xs) nil) ((funcall pred (car xs)) (car xs)) (t (find-first pred (cdr xs)))))

FIND-FIRST

Here's an example

(find-first #'evenp '(1 3 5 0 7 9))

0

Next, the following function checks if adding a given path to a graph creates a cycle.

(defun creates-cycle-p (path graph) (let ((e (find-first (lambda (x) (intersection path x)) graph))) (cond ((null e) nil) ((every (lambda (x) (member x path)) e) t) (t (creates-cycle-p (union path e) (remove e graph :test #'equal))))))

CREATES-CYCLE-P

And, finally an implementation for Kruskal's algorithm:

(defun kruskal (graph &optional tree) (if (null graph) tree (let ((e (elt graph (random (length graph))))) (kruskal (remove e graph :test #'equal) (if (creates-cycle-p e tree) tree (cons e tree))))))

KRUSKAL

Let us test:

(defparameter G '((0 1) (1 2) (1 3) (2 3) (0 4) (4 5) (3 5) (0 5))) (kruskal G)

G ((1 2) (0 4) (3 5) (0 1) (4 5))

[youzicha]

☕️ haskell extensions (particularly interested in RankNTypes and ImplicitParams)

I should say that I’m not a very advanced or experienced Haskell programmer! After some grepping, I think the biggest list of extensions I’ve used in a real project was

{-# LANGUAGE ViewPatterns, TypeSynonymInstances, ExistentialQuantification, NamedFieldPuns, ParallelListComp, FlexibleContexts, ScopedTypeVariables, TupleSections, FlexibleInstances #-}

which doesn’t seem very fancy. I’ve never been tempted to use ImplictParams, but I also haven’t worked on many projects.

As for RankNTypes, I guess I do have some thoughts. First, a while ago I came across an article OCaml Language Sucks, written by a Lisp programmer, and I was amused to see that one of his first complaints was that it doesn’t have higher-rank polymorphism:

e.g. the following code does not work: type t = MyInt of int | MyFloat of float | MyString of string let foo printerf = function  | MyInt i -> printerf string_of_int i  | MyFloat x -> printerf string_of_float x  | MyString s -> printerf (fun x -> x) s

because the first statement makes OCaml think that printerf has type (int -> string) -> int -> 'a instead of the correct ('a -> string) -> 'a -> 'b. (Yes, there are many workarounds, which make the problem look even more ugly).

In the the statically-typed world I feel it’s commonly assumed that Hindley-Milner is basically good enough, and that anything more than prenex-polymorphism is esoteric, but this guy apparently got burnt by it at least twice in his first year of OCaml programming.

Second, any time anybody mentions type inference for higher-ranked types I kindof flinch and feel inadequate, because I’ve tried to read various papers about the different inference algorithms, and I always have to give up halfway through. I still have no idea what GHC will actually do if you turn on the extension, and I now have some learned helplessness about the entire topic.

But third, I also suspect that trying to infer these types in the first place is just a bad idea! I do more programming in Coq than in Haskell, and the story there is simple: the programmer always needs to write explicit forall-quantifiers in the types and type-lambdas in the code, and it will make a best effort to infer type arguments using unification (but sometimes you need to write those explicitly too). And that’s absolutely fine! I’ve never felt that this is a big burden, and it means that polymorphism just works without any surprises at all. I feel Haskell is taking a simple thing (System F), and sticking an amazingly complicated Rube Goldberg contraption in front of it, and we could just... not do that...

[hackernewsrobot]

Let over Lambda – Common Lisp Book (2008)

https://letoverlambda.com/ Comments

[temporaryneckache]

Diving into Haskell with the Haskell Book

A few months back I was motivated to dive back into Haskell and, after surveying the recent landscape, picked up Haskell Programming from First Principles. It's a book that promises a soup-to-nuts approach to Haskell, staring from the mathematical concepts underscoring the language (Lambda calculus) and moving through to a full-blown production-ready project. I've so far gotten a few chapters in, and, while I haven't learned anything new, the authors' approach to the basics -- data types, constructors, etc -- are fairly conversational and comprehensive, and they do a good job of answering the questions that arise naturally while reading. (I'll ignore the likelihood that these same authors are leading into these questions, and answering them, to make me feel better about myself while reading. Why? Because it makes me feel better about myself, that's why. Well done, authors!)

Reading through this book I reflected on my first runthrough of Learn You a Haskell For Great Good when it came out (iirc it was early 2013). My programming career hasn't swerved headllong into functional programming; I'm coding Ruby now instead of the Python I was slinging back then, but these are still pretty apples-to-apples as far as languages go. I liked LYAHFGG a lot -- it's fun and thorough too -- but while set comprehensions and string operations made sense, I wasn't really making the jump from Python to typeclasses. The book that did help me crack into functional programming concepts was Functional Programming in Scala, not LYAHFGG. Here are some possible reflections why:

Haskell syntax is very spare, rather like poetry to Scala's prose; FPIS, by virtue of it's medium, surrounds novel FP concepts with familiar programming syntax (ie extra parens and curlys). This may not matter to everybody, but it seems to have been a bridge I needed.

Pattern matching, a concept at the core of Haskell's type definitions, doesn't really make sense in languages based on duck typing. Python and Ruby, lacking type constructors, can only can go as far offer some degree of tuple destructuring based on positional assignment. Scala and Haskell are solidly in the world of type constructor pattern matching, which is a vital concept on the road to understanding type classes.

Guards, 'where', and 'let' make sense to anybody with a discrete mathematics backrground, and 'expressions' are familiar from languages like Lisp and Scheme, but none of these are that present prevalent in Python. Ruby does have stronger support for expression syntax (ie assigining an entire 'if' or 'begin/rescue' statement to a variable).

Some other random notes:

The quicksort algorithm is the go-to for demonstrating Haskell's declarative power, and the quicksort section in LYAHFGG does a great job showing that. Algorithms in Haskell translate cleanly from general computer sciance. They tend to be composed definitions, not recipes.

I get that (+3) is a partial function adding 3 to whatever is passed in. I understand that it's really (+) 3. But it'll likely never be as clear to me as (\x -> x + 3), because that explicitness makes more sense. Once again, poetry vs prose.

FPIS nailed home the constructor-pattern matching thing in a way that made sense to my Java-related brain.

[e-tag]

Metacircular Interpreter.

Metacircular Interpreter. 

• (defun eval (form)     (cond ((symbolp form) (lookup form))               ((atom form) form)               ((consp form)                (let ((head (first form)))                  (cond ((eq head ‘quote) (second form))                            ((eq head ‘atom) (atom (eval (second form))))                            ((eq head ‘eq) (eq (eval (second form)) (eval (third form))))                            ((eq head ‘car) (car (eval (second form))))                            ((eq head ‘cdr) (cdr (eval (second form))))                            ((eq head ‘cond) (eval-cond (rest form)))                            ((eq head ‘lambda) (eval-lambda (rest form)))                            (t (let ((values (mapcar #‘eval form)))                                 (apply (first values) (rest values))))))))) 

Why Lisp? 

“LISP differs from most programming languages in three important ways. The first way is in the nature of the data. In the LISP language, all data are in the form of symbolic expressions usually referred to as S-expressions, of indefinite length, and which have a branching tree-type of structure, so that significant subexpressions can be readily isolated. [...] The second distinction is that the LISP language is the source language itself which specifies in what way the S-expressions are to be processed. Third, LISP can interpret and execute programs written in the form of S-expressions. Thus, like machine language, and unlike most other higher level languages, it can be used to generate programs for further execution.” 

(LISP 1.5 Programmer's Manual,1962)

http://prog.vub.ac.be/~pcostanz/documents/cs09/Meta.pdf

[gima326]

「4.2 トップダウンプログラミング」　その２

Doug Hoyte『LET OVER LAMBDA』(P96 - 103) …で、動くコードも書き終わったけれど、ここで言ってる「トップダウン」って、なんぞや？ 何度か読み返してみたが、こんな感じだろうか？ 　・ふつーの言語（Blub）でやるような、考察（設計ブレスト）からはじめるな 　・何にその言語（DSL）を使いたいかを考えろ もう少し具体的に、 　・ある言語（DSL）の簡潔な定義や実装を書きたいのなら、 　・まずは、その言語でのプログラムの書き方（問題の解き方）を知ろう 　・そのためには、その言語を構築するマクロのユースケースから始めよ …うーん。 ぜんぜん分からない。 抽象的すぎるよ、もう一声！ 　・時間単位を秒数で表現する「マクロ」を例示し、 　・それを「仕様」にまで「押し上げ」て 　・この種の、「単位を扱うマクロ」を作成するための「言語」（マクロ）を作る方法を考える手順をしめそう とゆー話の展開になる。 そんな「マクロ」のユースケースは、こんな感じ。 　・テーマ：「単位変換ヘルパー」を簡単な方法で定義する 　・問題を解くのに必要な「指示」、「情報」とは？（以下） 　　・時間についての単位変換である、という表明： time 　　・基本単位（秒）：s 　　・算出するためのデータ：units 　・「ひとひねり」として、データどうしに連鎖的な紐づけを持たせ、各レコードを【単位と相対係数のペア】にしてみよう …と、こんなふーに、Lisp プログラムを拡張する方法を考えることで、何かの問題を解決する「言語」を拡充させるんだ、と。

[douchebagbrainwaves]

AND IF IT'S NOT IMPOSSIBLE BUT SIMPLY VERY HARD, IT MIGHT BE EASY

The word now has such bad connotations that we forget its etymology, though it's staring us in the face of fierce competition. But if you control the whole system and have the source code. Earlier this year I wrote something that seemed suitable for a magazine, so I can answer for both. The organic growth guys, sitting in their garage, feel poor and unloved. But that might not be necessary. 9999 if they occur more than 10 times and. Below is the result of your feedback form is an instant giveaway. Kind of, but not his charisma, and he suffered proportionally. Well, that's news to no one. So while you'll probably survive, the problem now becomes to survive with the least damage and distraction.

Lisp programs into Python line for line. A real hacker's language, I think, is which 52% they are. A recent survey found 52% of companies are replacing Windows servers with Linux servers. It is a mistake to try to reverse the fortunes of a declining industrial town like Detroit or Philadelphia by trying to encourage startups. Where is the breakeven point? The outsourcing type are going to be an employee anymore—that blogs are just a fad. Where is the man bites dog in that? In addition to the direct cost in time, there's the cost in fragmentation—breaking people's day up into bits too small to be useful. On the blunderometer, this episode ranks with IBM accepting a non-exclusive license for DOS. It's the architectural equivalent of a home-made aircraft shooting down an F-18. The token Url optmails meaning optmails within a url occurs 1223 times. Writing eval required inventing a notation representing Lisp functions as Lisp data, and such a notation was devised for the purposes of the paper with no thought that it would be a curious state of affairs if you could get the right answer.

Because I wanted to keep the problem neat. In their own homes, which aren't even designed to be better, for a new techology, than a few years of being used only by a small number of early adopters. A hacker may only want to subvert the intended model of things once or twice in a big program is to start from the other end of the scale for tokens found only in the legitimate corpus. Suppose we could somehow feed these reporters false information about market closes, but give them all the other news intact. It's hard to convince investors the first time too, but there you face bureaucratic obstacles that would slow down a startup. We're not hearing about these languages because people are using them on servers. Presumably, if you want to know whether to recruit someone as a cofounder, ask if they are, we have no idea what our average returns might be, and won't know for years. But software, as a general rule, you can end up being more productive. Has aspects of that. Millions of people are publishing online, and the bureaucratic obstacles all medical startups face, they'll be going against thousands of years of medical tradition. I dislike being on either end of it.

This essay is derived from a talk at the 2003 Spam Conference. If any incompatibility arises, you can end up being more productive. Though this election is usually given as an example of the power of TV, Kennedy apparently would not have won without fraud by party machines in Illinois and Texas. A good example is the airline fare search program that ITA Software licenses to Orbitz. When I was in the search business. But if you parse it all, your filter might degenerate into a mere html recognizer. Another project I heard about after the Slashdot article was Bill Yerazunis' CRM114. In old hackers, skepticism predominates, and they seemed to me full of random stuff. One of my tricks for generating startup ideas is to imagine the ways in which we'll seem backward to future generations that we wait till patients have physical symptoms to be diagnosed with cancer. It might also be inevitable, if you could get to the point where everything could be done by bots, because then you'd have made the sufficiently smart compiler you could create in a couple years, but the first papers about Bayesian spam filtering per se seem to have just humiliated them technologically. But there is a limit on the number of simultaneous users will be determined by the amount of memory you need for whatever you end up with: def foo n: lambda i: return n i To be fair, Perl also retains this distinction, but deals with it in typical Perl fashion by letting you omit returns. Often, indeed, it is not clear whether you can actually solve this problem.

And now that I'm an investor, the thought of our investors used to keep me up at night. Of course the ultimate in brevity is to have a language designed by a committee. Why is everyone smiling? What all this implies is that there is a name for the phenomenon, Greenspun's Tenth Rule: Any sufficiently complicated C or Fortran program contains an ad hoc informally-specified bug-ridden slow implementation of half of Common Lisp probably expected users to have text editors that would type these long names for them. Like open source, blogging is something people do themselves, for free, those worlds resemble market economies, while most companies, any development project that would take five years is likely never to get finished at all. They're tools, designed for people, and how do you deliver drama via the Internet? As long as he considers all languages equivalent, all he has to do is keep telling your story, and eventually people will start to hear. To be fair, Perl also retains this distinction, but deals with it in typical Perl fashion by letting you omit returns. Anyone who has worked on spam filters, this will seem a perverse decision. I mean. But if they don't want to wait for Python to evolve the rest of the creative class—you probably have to ban large development projects.

Because he had grown up there and remembered how nice it was. It's just that if I can't write things down, worrying about remembering one idea gets in the way of redesign. Om Malik is the most recent of many people to ask why Twitter is such a big problem that changing the way people do it will have a wave of secondary effects. Which leaves two options, firing good people and making more money. They did it because they genuinely like to program and aren't satisfied with the languages they already know. And that means, perhaps surprisingly, that it has today. Finally, they didn't bias against false positives. I know the structs are just vectors underneath. To start with, it must be, because I still have no trouble catching these spams.

They're each only a great university short of becoming a silicon valley, is a language in its own right. A more serious problem is the real one. Most of the legal restrictions on employers are intended to be the ones you end up looking at when you get filters really tight. They want to get a big program is to start with a throwaway program is something that you expect to write in an hour. Suppose we could somehow feed these reporters false information about market closes, but give them all the other news intact. Otherwise we don't care. If anyone wants to write aref a x y instead, which is about 2. Just write whatever you want and don't cite any previous work, and indignant readers will send you references to all the papers you should have cited. That sounds harmless. The big advantage of investment over employment, as the examples of open source and blogging? If you find a lot of C and C as well as money.

More significant, I think is a red herring. Free If you do that you raise too many expectations. Companies spend millions to build office buildings for technology companies won't get you a silicon valley, you not only need a university, but one of the founders we funded asked me why we started Y Combinator is how frightening the most ambitious people are probably best off approaching them obliquely. It would be a way to finesse our way out of the wrong concepts. People can notice you've replaced email when it's a fait accompli. But often memory will be the most important places for learning about new languages like Perl and Python at their own game. For example, a friend came to visit from New York. 8747 From free 0. When I wrote A Plan for Spam I hadn't had any, and I didn't know what they'd be like.

Thanks to Paul Buchheit, Harj Taggar, and Stan Reiss for reading a previous draft.

[hydralisk98]

HypathyLambda (Multimedia Manifestation Collaging Prep P:1/?, for both 16^12 and CR)

Challenge restrictions:

First set of keywords: Vectorheart, ecosyndicalism, mysticism, cassette futurism (datasettes?), ArtDeco, Banhaus, Belle Epoque, soft warm retrofuturistic grunge, stylized SVG toon, solarpunk oxymorons, tarot deque / witchcore, matte plastics groovy commune, political intrigues, cute yet aliased NPR look, open culture copyleft, "Helluva Boss", "Wakfu", "Powerpuff Girls", "Nicky Case", "FreeCiv" chess tileset, Civilization 5 G&K+BNW (CE), PETSCII, retrocomputing fontmap semi-graphics, symbolic computation / computer-assisted-algebra, time mystery, lunarpunk, neo-brutalism LPS in the woods, "Soyuzmultfilm", soviet space program Venus probes, analog media (45rpm 7" autoplay records), hoof shoes, biomods & cyberware, data processor VLSI facilities, light academia library painted black... harmonious innovation yet horrendous discord;

Artix Linux KDE Plasma + Liquid desktop environment, GLOSS software ecosystem... Common Lisp -> custom Lisp-y dialect derived from make-a-lisp (mal) project;

(Verbs, Subjects, Lambda aka ANY adjectives...)

Klara "Olive" Kér (INTJ)

Ava Noonlight (ENFP)

Shoshona (black angora cat... shapeshifter?)

Vera, Tano, Bel, Nil, Constans...

List-y mess of keywords

Medium Light & Medium Dark Gruvbox, very dark night with dim yet soft & warm lights, Shoshona the black Angora housecat, solarpunk, 16^12, witchy coven commune, walking her way to her own home library, forested library location, night, hoof shoes, black gloves (giving the blackhand surname), relaxing 45rpm 7" vinyls’ music, bell thousers, jackets / blouse, black lipstick, white hoof shoes, daybreak / dusk, black sun, stargazing, retro warm grunge look with black white and amber tones, large backpack, amber polka dot patterned identity card, libre cyberware & libre bioware, GLOSS (gratis, libre, open source software / culture), olive & black net socks texture, soft woolen rug texture, notepad at her hand, soundscape of a forested park library with some river nearby, cozy vibe of curiosity and knowledge-seeking…

Some majestic Lisp poetry & code booklets on the shelves, puffy layered turtleneck shirt and bell cap trousers, Olive Synod Mixnet library card, autistic fem symbol talisman, keychain charms, analog medium, retro computers, axis victory?, anti-Wilsonism, Strasserism, Shoshoni language, conlangs, alternate technologies, mysticism, communion, community building, honest humble living, witch coven, STEM ladies, Chronokinesis, True Polymorphs, Toymaker, open culture, public domain, copyleft, desktop environmental storytelling, REPL feedback loops, Lisp symbolic computation machines, addventure, neo-brutalism, systemic change, historical retrospective, from grim dark to bright solarpunk, Konrad Zuse, factions, far far away future foresight, van hexcrawl, encyclopedic knowledge, life-long learning, Zettelkasten, Markdown, Argdown, DolDoc, Parade FS, DocBook, HTML, XML, SVG toons, Common Lisp, Worker Cooperatives, KDE-Plasma’s Kate;

Neue Geo-Syndicalist constructivist empowerment worldview, Lisp program forms as Lisp-y poetry, mysticism, geofiction realms & speculative paracosms, constructed languages’ jargon / dialects and technological systems…

So let us imagine a multimedia (game? movie? book?) project around the fundamental prompt / question of “Regardless of context, what does it take for us to bring forth the future we deserve?”;

Maskoch, Shoshoni Union… May 4525; INTJ (Kate Kér, sapient-tier human Shoshoni self-insert) & ENFP (Ava, synthetic-tier android blonde lady) duet, with Shoshona the black angora cat, and Nil the camera-person perspective.

Harmony, Progress, Liberty, Knowledge, Transparency, Copyleft / Open Culture;

Ok, so let’s imagine animated films where Kate literally records comforting memories of herself alongside Ava and Shoshona, reading books and whatever else. And also simply living their best lives.

Lisp-vy mess of multimedia (visuals, audio and video... assets)

[v-i-t-h-blog]

Языки программирования

Это пост о языках программирования, которые знаю или с которыми знаком. Мне приходилось писать код на различных языках и обычно тот язык на котором пишешь долго знаешь лучше остальных. Первые программы пробовал писать на С++ (не считая фохпро но о нем не буду писать). Не выбирал этот язык сознательно, просто сказали, что такой язык существует и в магазине были книжки по нему. Это все было очень давно. Сейчас из С++ помню только какие-то совсем простые вещи. Время проходит и многое выветривается из головы. Впрочем, уверен, что если начать на нем писать снова, то смогу это сделать. Не на уровне профи, но хотя бы базовые конструкции.

Второй язык - ассемблер. Точнее ассемблер для процессоров x86. Но тогда я этого не знал. Это было очень интересно, копаться на таком низком уровне, смотреть что там “на самом деле” происходит. Как в действительности устроен цикл - что это всего лишь переход по условию на метку (JB LoopAgain), что такое вызов функции - а это тоже переход но с предварительным сохранением адреса возврата в стек (параметры туда же). Как организована память, биты, байты, слова. Как можно одной инструкций закинуть картинку на экран - записать c помощью REP MOVSW сразу в видеопамять. Из книжки по программированию игр узнал как вставлять инлайн ассемблер код прямо в C код.

Третий язык - Object Pascal. С начала не сильно понравился. Синтаксис был какой-то непривычный, казалось что он ограничивает сильно, не было такой свободы как в предыдущих языках. Так тогда казалось. Но он был в среде разработки Delphi, а там можно было набросать программу буквально парой движений мыши. Я сравнивал с разработкой в Windows на C++, где приходилось фигачить длинный листинг чтобы только одно окно с кнопкой нарисовать, вручную работать с циклом событий, вручную подключать ресурсы. Вообщем Delphi ошеломил меня своей простотой и скоростью. В самом языке было много похожего на C++. Обучение прошло быстрее. Позже я понял, что все языки подобного типа похожи. Сход��ые конструкции, идеи, подходы.

Четвертый язык Ruby. Я заинтересовался веб программированием и тогда в тренде был Ruby on Rails - фреймворк для быстрой разработки. С помощью буквально одной строки в консоли можно было создать работающий блог. Это было поразительно. Я сравнивал с тем количеством времени что я провел как-то в PHP (язык который я никогда толком не учил) чтобы сделать подобное. С начала я долго занимался рельсами (RoR) не особо вникая в сам язык. Потом понял, что так не получится, что без языка уходит много времени на понимание. Нашел книжки, прочитал. Язык оказался красивым, сделанным специально для программистов (так он позиционировался). Лаконичный, краткий код. Очень удобные и выразительные конструкции. Здесь я впервые столкнулся с идеей, что все есть объект. И это действительно оказалось так, или почти так. Конструкции вида 3.times { | n | puts n } с начала казались странными - как это вообще может работать?! Фактически язык выглядел так, как будто все в нем живое. Писать код было одно удовольствие. В нем правда были странные конструкции, точнее сейчас кажутся странными. Например использование 2х видов “лямбд” - есть lambda, а есть Proc. И отличия довольно тонкие. Довольно сложное ООП - если копаться глубоко. Например метод при вызове ищется довольно хитрым образом, на самом объекте (если метод синглетон), в модулях которые расширили объект, в классе объекта, в модулях которые добавлены в класс... если ничего не нашлось то на сцену выйдет method_missing и либо вызовет исключение, либо, если его переопределили, сделает что-то еще - обычно таким образом реализуют метапрограммирование. Можно создать фактически язык внутри языка. На руби хорошо выходят DSL (Domain Specific Language). Те же рельсы яркий пример. Конструкции кажутся специально сделанными для предметной области.

Отдельно упомяну “учебные” языки. На них ничего серьезного не писал, но использовал для прохождения курсов в основном.

Lisp (Racket, Clojure) - очень мне понравился невероятной гибкостью и очень простым синтаксисом, который можно выучить буквально за несколько минут). Идея что оператор “+” тоже функция, да и “-” тоже - это было очень свежо. А еще функции высших порядков, передача и возврат функций. Это заставляет совсем по другому смотреть на код.

Octave - Матлаб подобный язык, использовал только раз для прохождения курса по Machine Learning. Запомнился довольно странным синтаксисом. Python - очень похож на Ruby. Я долгое время на питон не смотрел, мне казалось зачем питон, если есть руби. Но пришлось, так как почти все курсы на питоне. А потом оказалось что и в ML везде питон.

R - язык для ML и статистики. Диковинный синтаксис, но для своих целей удобен и выразителен. Не учил его толком, для курсов хватило самых поверхностных знаний.

Java - никогда особо не тянуло учить джаву, но пришлось для курса. Долго мучился с настройкой. А запуск из командной строки - это просто нечто, запускаешь команду с тучей флагов и настроек, потом вторую чтобы запустить на исполнение. Сам язык показался тяжеловесным и многословным, буквально все нужно описывать руками. 

SML (Standard ML) - для курса “Programming languages”. Интересный язык. Строгий с статической типизацией. Но я замучился на нем писать в начале. Я буквально не понимал, почему программа не компилируется. Ошибки были не понятными. Здесь для меня было открытие что есть statement а есть expression и что последнее вычисляется и его можно вставить куда угодно. А еще что все ветки в функции должны выдавать одинаковый тип. А еще я не понимал вовсе как писать логику внутри функции, тут просто нельзя ничего “повесить в воздухе” обязательно нужно чтобы было какое-то выражение которые вычислится и функция его вернет. Долго въезжал в конструкции let ... in, вот как-будто простая идея, но непривычна. Вообще идея что значение связывается с неким идентификаторы была непривычной. Именно связывается, а не записывается куда-то в память. Так постепенно начинаешь думать не о переменных а о связанных идентификаторах (bindings).

Scala - не помню зачем я взял этот курс. Но благодаря ему я познакомился с азами функционального программирования. В руби я использовал map, но здесь я узнал еще про reduce (сразу ничего не понял) казалось, ну кому в голову прийдет так извращаться с массивом. Концепция иммутабельности сразу не впечатляла, думал, ну это же мука, постоянно создавать новые константы, а списки тоже мэпить из одного в другой. Но оказалось, что это все полезно и местами удобно. Совсем другой стиль мышления нужен. Сам язык очень богатый, позиционируется как сплав ООО и ФП.

Haskell - курс на Stepic. Похож на SML, учить было уже сильно проще. Новым были пожалуй монады. Но курс я проходил давно, и они выветрились из головы. Решил буквально недавно пройти его снова, хочется использовать эти знания �� работе. Благо в моем текущем языке (JS), подобные конструкции построить можно (хоть и сложнее).

Мой текущий язык - JavaScript. Я знаком с ним очень давно (больше 10 лет назад в первый раз увидел). Но никогда толком не учил, казалось что я его и так знаю, ну что там учить - синтаксис как в С, семантика похожа. А после руби мне он казался еще и не очень красивым и громоздким. Я старательно уклонялся от того, чтобы писать на нем. Но мне предложили работу и пришлось поменять отношение. На мой первый пулл-риквест мне дипломатично сказали, что “есть куда расти”, имея ввиду что уровень владения языком был слабый. Я знал только базовый синтаксис, не владел идиомами языка. Поэтому первое время я читал книги и смотрел ролики и пытался что-то понять. Оказалось, ну кто бы мог подумать! что тут есть даже классы, но наследование прототипное. Я не понимал что это значит. Эта концепция далеко не сразу далась. А еще здесь есть this, который как self в руби думал я. Но оказалось что ничего подобного. А потом оказалось, что классы никакие вообще не классы, а есть только функции конструкторы, а еще есть прототипная цепочка, в которой ищутся свойства и методы. Хотя нет, методов тут тоже нет, если только функции, объект строго говоря вообще своими функциями не владеет, кто угодно может их вызвать “для себя”. А еще есть приведение типов, от которого может пойти голова кругом, и над которым многие смеются. Хотя, если разобраться, то не такое уже оно и странное. Со временем мне стал нравится этот язык - оказалось что в нем есть почти все для функционального программирования - можно построить и монады и функторы и все что угодно. Можно построить и ООП в разных стилях. Он очень гибкий. При построении абстракций код может стать довольно красивым (библиотека Ramda например). Это просто удивительно для языка, который создали за такой короткий срок.  

[tariqk]

Thinking about Lisp, software development and collaboration.

So like I've been reading a lot of Paul Graham's On Lisp, and Doug Hoyte's Let Over Lambda, and it's been... interesting.

Cut to spare the timeline.

Like, I don't pretend that I understand these works completely, or that I have anything more than a semi-functional understanding of Lisp — most of my work on Lisps have been on Emacs Lisp, which is really showing it's age, and I've honestly never touched macros in any reasonable level, because honestly speaking macros have a frightening reputation. Thanks to Graham and Hoyte's walkthrough of some of the concepts, though, I think my understanding's a little better, though it can only be tested if I can implement stuff on Common Lisp, if that day ever comes.

What struck me about the commentary was that, well, how much both Hoyte and Graham are fans of the language, and how they often extol its virtues. To both of them, Lisp is something that transcends other languages, that allow programmers to do things that are closer to the problem domain than anything else that people have made. That, when you make a programming language approach the kind of power, extensibility and flexibility that Lisp does, surprise! You've made another flavor of Lisp.

This is a seriously grand claim, but I kept being bugged by one question:

If Lisp Was So Good, Why Isn't It Used More Often?

Like, seriously, I kept reading these claims, and to some degree I could see them backing these claims with examples... and yet if you look at Common Lisp and Scheme projects on the Internet... they're like... scattered and fragmented. You can code, and most importantly, an overwhelming number of people do, from the beginning to the end, full-stack web applications in JavaScript. Lua gets used in everything from window managers to video games customization to desktop widgets. Python's still prevalent in web development to data sciences, and yes, some video games are customized in Python. Like, Ruby was everywhere for a while before it receded.

Like the only exceptions to this are, I guess, Emacs Lisp, which basically sticks with Emacs, and Clojure, which is tied to the JVM, and ClojureScript, which outputs JavaScript. Note how reliant they are on other software and frameworks.

The Answers I've Seen So Far

So, what gives? Like, I've been looking around, and I've seen basically two answers:

Lisp Isn't Popular Because People Are Stupid

No, seriously. This is the argument. Paul Graham engages in it:

People frightened by Lisp make up other reasons for not using it. The standard excuse, back when C was the default language, was that Lisp was too slow. Now that Lisp dialects are among the faster languages available, that excuse has gone away. Now the standard excuse is openly circular: that other languages are more popular.

(Beware of such reasoning. It gets you Windows.)

Popularity is always self-perpetuating, but it's especially so in programming languages. More libraries get written for popular languages, which makes them still more popular. Programs often have to work with existing programs, and this is easier if they're written in the same language, so languages spread from program to program like a virus. And managers prefer popular languages, because they give them more leverage over developers, who can more easily be replaced.

Hoyt engages in this, as well:

Macros have, not by accident, almost as much history as lisp itself, being invented in 1963 by Timothy Hart[MACRO-DEFINITIONS]. However, macros are still not used to the fullest possible extent by most lisp programmers and are not used at all by all other programmers. This has always been a conundrum for advanced lispers. Since macros are so great, why doesn't everybody use them all the time? While it's true that the smartest, most determined programmers always end up at lisp macros, few start their programming careers there. Understanding why macros are so great requires understanding what lisp has that other languages don't. It requires an understanding of other, less powerful languages. Sadly, most programmers lose the will to learn after they have mastered a few other languages and never make it close to understanding what a macro is or how to take advantage of one. But the top percentile of programmers in any language are always forced to learn some sort of way to write programs that write programs: macros. Because it is the best language for writing macros, the smartest and most determined and most curious programmers always end up at lisp.

I mean, the argument is pretty clear: because Lisp is so powerful, and that it takes so much study and effort to work at it, that only top-tier programmers are the only ones who understand Lisp. Implied, however, is the assumption that if you don't get Lisp, well, you're not a top-tier programmer, and you Just Don't Get It.

Which gets to the second explanation of why Lisp isn't popular:

Lisp Users Are Assholes

I mean, the above quotes are a sampling, and, honestly, a mild one, of the perceived attitudes of Lisp aficianados to the outside world. And it doesn't help that Hoyt then proceeds to call other non-Lisp Languages “Blub”, which, despite his many attempts to soften the blow, just makes him sound like an asshole. Like, you could have said “other languages”, dude. Sure it's less efficient, but you're dealing with people, not machines.

Like, Mark Tarver has an essay about the assholishness of Lisp users, which I don't recommend you read, because CONTENT WARNING ableism1. Maybe if you wanna take a look at commentary on that, you can go for Rudolf Winestock's The Lisp Curse, which is a little better, I guess?

Lisp is so powerful, that it encourages individual independence to the point of bloody-mindedness. This independence has produced stunningly good innovation as in the Lisp Machine days. This same independence also hampers efforts to revive the “Lisp all the way down” systems of old; no “Lisp OS” project has gathered critical mass since the demise of Symbolics and LMI.

[...]

Why [doesn't the Lisp community] make a free development system that calls to mind some of the lost glories of the LispM, even if they can't reproduce another LispM?

The reason why this doesn't happen is because of the Lisp Curse. Large numbers of Lisp hackers would have to cooperate with each other. Look more closely: Large numbers of the kind of people who become Lisp hackers would have to cooperate with each other.

The argument is, commercially, if you're a brilliant asshole, no one wants you. While your brilliance would be an asset for a while, what really makes organizations and enterprises scale isn't the fact that they hire brilliant people, but that they hire and use people brilliantly, in ways that are robust and don't rely on having the Right Kind of People on board. It's also why computer security is such a fucking thing to get right, because most of the solutions seem to be... hire the best in the industry and go with that? Which works great until your Chief Security Officer gets run over by a bus a better offer from the competition. Then what?

I mean, yes, capitalist models rely on you having a development workforce that is fungible, because it is cheaper in the long run, but it also reduces risk, even if reducing labor costs aren't a thing for you. It's also more democratic that way, because, yes, you need it to be accessible and approachable to the people who are affected by your code. And it needs to be reproducible, because if not, what if it's scientific work and we need to verify it?

But, even then, this diagnosis — that, charitably, the expressiveness of Lisp attracts brilliant assholes who can't even be convinced to work with one another rankles, because it fundamentally means that there's no solution. The language is too good for normies, and only assholes will use it, ∴ that's the end. Nothing more can be said.

I wonder if there's more to it. And I suspect there might be.

The Social Models Around Lisp Might Actually Be Toxic

Notice the commonality around the four people I've quoted above?

Yup.

They're all white dudes.

I'm not saying that the Lisp community is so toxic because the loudest voices within Lisp are all white men. I'm saying that the fundamental assumptions that these white men have about what is good might actually be a reason why Lisp's community might be so toxic.

There's a difference. Bear with me.

Graham actually talks about the process of developing software in Lisp — the bottom-up approach — but he talks about it in a way that assumes that development occurs with a single person, and that the final vision of the problem space is the insight of one person, or a small group of people with a common enough vision: sort of a Cathedral-style system. Does it have to be?

Why can't bottom-up development occur in a collaborative, cooperative system? Sure, Lisp “doesn't have syntax” (which always weirded me out — it does have syntax, just one that's “invisible” and “self-evident” to a certain class of mind). One that eschews the models that we're used to in capitalist and hegemonic systems. If Lisp is one of the purest forms of mathematical expression, what Hoyt refers to as a “U-Language”, shouldn't it be universally accessible and open to critique?

Maybe the reason why Lisp doesn't work is because the social models around Lisp — one that erases and diminishes the contributions and the lives of people who aren't white men of a certain analytical mindset — make it fail. Maybe whiteness — the social construct, one that lionizes individual brilliance of a specific kind, emphasizes competition over collaboration, pretends that there is an Objective™ Truth over the experiences of others, and considers all emotions other than violent, abusive ones weakness — is the reason why Lisp fails, despite its expressiveness and power.

Maybe the way to do it is to change the way people learn Lisp, and work with Lisp, and collaborate with Lisp, rather than the model we have today.

Could something like that, a system that allows easy, safe collaboration, and organisations that deliberately go for minority and disadvantaged groups, be something that could kick Lisp out of its doldrums?

He calls these people “brilliant bipolar minds”, because, of course. Just because you can diagnose the problem doesn't mean that you don't have the problem as well. ↩︎